PlutoTest.jl

👀 Reading hidden code

172 μs

This notebook introduces visual testing:

👀 Reading hidden code

220 μs

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(20 - 11))))) == 3

👀 Reading hidden code

@test sqrt(20-11) == 3

7.2 ms

iseven($(Main.workspace#5.Computed(123 + $(Main.workspace#5.Computed(7 ^ 3)))))

👀 Reading hidden code

@test iseven(123 + 7^3)

285 μs

$(Main.workspace#5.Computed(4 + 4)) ∈ $(Main.workspace#5.Computed([1:7...]))

👀 Reading hidden code

@test 4+4 ∈ [1:7...]

304 μs

👀 Reading hidden code

59.3 μs

👀 Reading hidden code

74.1 μs

is_good_boy($(Main.workspace#5.Computed(first($(Main.workspace#5.Computed(friends))))))

👀 Reading hidden code

@test is_good_boy(first(friends))

264 μs

👀 Reading hidden code

friends = Any[Hannes, Floep];

17.0 μs

👀 Reading hidden code

Hannes = let

url = "https://user-images.githubusercontent.com/6933510/116753174-fa40ab80-aa06-11eb-94d7-88f4171970b2.jpeg"

data = read(download(url))

PlutoUI.Show(MIME"image/jpg"(), data)

end;

138 ms

👀 Reading hidden code

Floep = let

url = "https://user-images.githubusercontent.com/6933510/116753861-142ebe00-aa08-11eb-8ce8-684af1098935.jpeg"

data = read(download(url))

PlutoUI.Show(MIME"image/jpg"(), data)

end;

46.1 ms

is_good_boy (generic function with 1 method)

is_good_boy(x) = true

👀 Reading hidden code

367 μs

Tests have time-travel functionality built in! Click on the tests above.

👀 Reading hidden code

263 μs

Time travel

👀 Reading hidden code

171 μs

This notebook contains visual debugging:

👀 Reading hidden code

231 μs

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt(5)))))))))

$(Main.workspace#5.Computed(md"# Wow"))

end

@visual_debug begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

md"# Wow"

end

👀 Reading hidden code

14.8 ms

(You need `Pluto#main` to run this notebook)

👀 Reading hidden code

177 μs

TableOfContents()

👀 Reading hidden code

11.4 μs

using HypertextLiteral

👀 Reading hidden code

5.2 ms

using PlutoUI

👀 Reading hidden code

173 ms

import Test

👀 Reading hidden code

163 μs

@test_deprecated (macro with 1 method)

begin

export test_nowarn, test_warn, test_logs, test_skip, test_broken, test_throws, test_deprecated

var"@test_warn" = Test.var"@test_warn"

var"@test_nowarn" = Test.var"@test_nowarn"

var"@test_logs" = Test.var"@test_logs"

var"@test_skip" = Test.var"@test_skip"

var"@test_broken" = Test.var"@test_broken"

var"@test_throws" = Test.var"@test_throws"

var"@test_deprecated" = Test.var"@test_deprecated"

end

👀 Reading hidden code

472 μs

Type definitions

👀 Reading hidden code

166 μs

abstract type TestResult end

👀 Reading hidden code

340 μs

abstract type Fail <: TestResult end

👀 Reading hidden code

347 μs

abstract type Pass <: TestResult end

👀 Reading hidden code

325 μs

Any

const Code = Any

👀 Reading hidden code

106 μs

# struct Correct <: Pass

# expr::Code

# end

👀 Reading hidden code

9.0 μs

struct CorrectCall <: Pass

expr::Code

steps::Vector

end

👀 Reading hidden code

1.4 ms

# struct Error <: Fail

# expr::Code

# error

# end

👀 Reading hidden code

10.1 μs

# struct Wrong <: Fail

# expr::Code

# step

# end

👀 Reading hidden code

9.3 μs

struct WrongCall <: Fail

expr::Code

steps::Vector

end

👀 Reading hidden code

1.8 ms

Test macro

👀 Reading hidden code

180 μs

Main.workspace#5.WrongCall

$(Main.workspace#5.Computed(1 + $(Main.workspace#5.Computed($i))))

map(1:10) do i

@test 1 + $i

end

👀 Reading hidden code

45.3 ms

Main.workspace#5.WrongCall

$(Main.workspace#5.Computed(1 + $(Main.workspace#5.Computed(i))))

map(1:10) do i

@test 1 + i

end

👀 Reading hidden code

23.0 ms

Expr

:(1 + $(Expr(:$, :(Main.workspace#5.Computed([2, 3])))))

:($(Expr(:$, :(Main.workspace#5.Computed(1 + $(Expr(:$, :(Main.workspace#5.Computed([2, 3])))))))))

@eval_step_by_step 1 + [2,3]

👀 Reading hidden code

9.4 ms

test (generic function with 1 method)

function test(expr, extra_args...; __module__)

step_by_step

Test.test_expr!("", expr, extra_args...)

quote

expr_raw = $(QuoteNode(expr))

try

# steps = @eval_step_by_step($(expr))

steps = $(step_by_step(expr; __module__=__module__))

# arg_results = [$((expr.args[2:end] .|> esc)...)]

# result = $(esc(:eval))(Expr(:call, $(expr.args[1] |> QuoteNode), arg_results...))

result = expand_computed(last(steps))

if result === true

CorrectCall(expr_raw, steps)

# elseif result === false

# WrongCall(expr_raw, steps)

else

WrongCall(expr_raw, steps)

end

catch e

rethrow(e)

# Error(expr_raw, e)

end

👀 Reading hidden code

2.1 ms

👀 Reading hidden code

9.5 μs

begin
    var"#692#expr_raw" = $(QuoteNode(:(x == [1, 2 + i])))
    try
        var"#693#steps" = Expr[:($(Expr(:$, :(Main.workspace#5.Computed(x)))) == [1, 2 + i]), :($(Expr(:$, :(Main.workspace#5.Computed(x)))) == $(Expr(:$, :(Main.workspace#5.Computed([1, 2 + i]))))), :($(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(x)))) == $(Expr(:$, :(Main.workspace#5.Computed([1, 2 + i])))))))))]
        var"#694#result" = Main.workspace#9.expand_computed(Main.workspace#9.last(var"#693#steps"))
        if var"#694#result" === true
            Main.workspace#9.CorrectCall(var"#692#expr_raw", var"#693#steps")
        else
            Main.workspace#9.WrongCall(var"#692#expr_raw", var"#693#steps")
        end
    catch var"#697#e"
        Main.workspace#9.rethrow(var"#697#e")
    end
end

var"@test"; macroexpand(@__MODULE__, :(@test x == [1,2+i]); recursive=false) |> prettycolors

👀 Reading hidden code

38.0 ms

# e = :(x == [1,2+2])

👀 Reading hidden code

9.3 μs

Int64

x = [1,3]

👀 Reading hidden code

13.6 μs

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(missing)) == 2))

@test missing == 2

👀 Reading hidden code

247 μs

$(Main.workspace#5.Computed(2 + 2)) == $(Main.workspace#5.Computed(2 + 2))

@test 2+2 == 2+2

👀 Reading hidden code

287 μs

$(Main.workspace#5.Computed(x)) == $(Main.workspace#5.Computed([1, 2 + 2]))

👀 Reading hidden code

285 μs

$(Main.workspace#5.Computed(rand(50))) == $(Main.workspace#5.Computed([rand(50), 2]))

@test rand(50) == [rand(50),2]

👀 Reading hidden code

21.3 ms

always_false($(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(howmuch))))), $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(howmuch))))), 123)

@test always_false(rand(howmuch), rand(howmuch),123)

👀 Reading hidden code

349 μs

@bind howmuch Slider(0:100)

👀 Reading hidden code

279 ms

!($(Main.workspace#5.Computed(always_false($(Main.workspace#5.Computed(rand(2))), $(Main.workspace#5.Computed(rand(2))), 123))))

@test !always_false(rand(2), rand(2),123)

👀 Reading hidden code

341 μs

false

@test !!always_false(rand(2), rand(2),123; r=123)

👀 Reading hidden code

41.5 ms

false

@test always_false([1,2,3]...)

👀 Reading hidden code

2.8 ms

always_false (generic function with 1 method)

always_false(args...; kwargs...) = false

👀 Reading hidden code

1.2 ms

$(Main.workspace#5.Computed(isless($(Main.workspace#5.Computed(2 + 2)), 1)))

@test isless(2+2,1)

👀 Reading hidden code

298 μs

$(Main.workspace#5.Computed(isless(1, $(Main.workspace#5.Computed(2 + 2)))))

@test isless(1,2+2)

👀 Reading hidden code

265 μs

@bind n Slider(1:10)

👀 Reading hidden code

670 μs

iseven($(Main.workspace#5.Computed($(Main.workspace#5.Computed(n)) ^ 2)))

@test iseven(n^2)

👀 Reading hidden code

14.0 ms

@bind k Slider(0:15)

👀 Reading hidden code

613 μs

$(Main.workspace#5.Computed(4 + 4)) ∈ $(Main.workspace#5.Computed([1:k...]))

@test 4+4 ∈ [1:k...]

👀 Reading hidden code

290 μs

isempty($(Main.workspace#5.Computed($(Main.workspace#5.Computed(1:$(Main.workspace#5.Computed(k)))) .^ 2)))

@test isempty((1:k) .^ 2)

👀 Reading hidden code

321 μs

Main.workspace#5.WrongCall

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed($i))))) < 3

map(1:10) do i

@test sqrt($i) < 3

end

👀 Reading hidden code

23.1 ms

Main.workspace#5.WrongCall

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(i))))) < 0

map(1:10) do i

@test sqrt(i) < 0

end

👀 Reading hidden code

23.2 ms

$(Main.workspace#5.Computed(isempty($(Main.workspace#5.Computed([1, sqrt(2)])))))

@test isempty([1,sqrt(2)])

👀 Reading hidden code

15.5 ms

$(Main.workspace#5.Computed(1 ∈ $(Main.workspace#5.Computed([sqrt(20), 5:9...]))))

👀 Reading hidden code

308 μs

$(Main.workspace#5.Computed(1 ∈ $(Main.workspace#5.Computed(rand(60)))))

👀 Reading hidden code

259 μs

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(rand(60))) ∋ 1))

👀 Reading hidden code

258 μs

html"""

<style>

pt-dot {

flex: 0 0 auto;

background: grey;

width: 1em;

height: 1em;

bottom: -.1em;

border-radius: 100%;

margin-right: .7em;

display: block;

position: relative;

cursor: pointer;

}

pt-dot.floating {

position: fixed;

z-index: 60;

display: none;

transition: transform linear 120ms;

}

.show-top-float > pt-dot.floating.top {

display: block;

}

.show-bottom-float > pt-dot.floating.bottom {

display: block;

}

pt-dot.floating.top {

top: 5px;

}

pt-dot.floating.bottom {

bottom: 5px;

}

.fail > pt-dot {

background: #f75d5d;

}

.pass > pt-dot {

background: #56a038;

}

.pass > pt-dot.floating {

opacity: 0;

pointer-events: none;

}

.pluto-test {

font-family: "JuliaMono", monospace;

font-size: 0.75rem;

padding: 4px;

min-height: 25px;

}

.pluto-test.pass {

color: rgba(0,0,0,.5);

}

.pluto-test.fail {

background: linear-gradient(90deg, #ff2e2e14, transparent);

border-radius: 7px;

}

.pluto-test>.arg_result {

flex: 0 0 auto;

}

.pluto-test>.arg_result>div,

.pluto-test>.arg_result>div>pluto-display>div {

display: inline-flex;

}

.pluto-test>.comma {

margin-right: .5em;

}

.pluto-test.call>code {

padding: 0px;

}

.pluto-test.call.infix-operator>div {

overflow-x: auto;

}

.pluto-test {

display: flex;

align-items: baseline;

}

.pluto-test.call.infix-operator>.fname {

margin: 0px .6em;

/*color: darkred;*/

}

/* expanding */

.pluto-test:not(.expanded) > p-frame-viewer > p-frame-controls {

display: none;

}

.pluto-test.expanded > p-frame-viewer {

max-width: 100%;

}

.pluto-test.expanded > p-frame-viewer > p-frames > slotted-code > line-like {

flex-wrap: wrap;

}

.pluto-test.expanded > p-frame-viewer > p-frames > slotted-code > line-like > pluto-display[mime="application/vnd.pluto.tree+object"] {

/*flex-basis: 100%;*/

}

"""

👀 Reading hidden code

113 μs

html"""

<style>

p-frame-viewer {

display: inline-flex;

flex-direction: column;

}

p-frames,

p-frame-controls {

display: inline-flex;

}

"""

👀 Reading hidden code

123 μs

always_false($(Main.workspace#5.Computed(rand(20))), $(Main.workspace#5.Computed(rand(20))), 123)

t = @test always_false(rand(20), rand(20),123)

👀 Reading hidden code

289 μs

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) - $(Main.workspace#5.Computed(3 + 4))))

false

end

@test begin

(1+2) - (3+4)

false

end

👀 Reading hidden code

2.7 ms

$(Main.workspace#5.Computed(#= /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3 no interpolate.jl#==#176f39f1-fa36-4ce1-86ba-76248848a834:1 =# @test(always_false(rand(3), rand(3), 123)))) isa $(Main.workspace#5.Computed(Fail))

@test (@test always_false(rand(3),rand(3),123)) isa Fail

👀 Reading hidden code

16.3 ms

always_false($(Main.workspace#5.Computed("asd" * "asd")), "asd", $(Main.workspace#5.Computed("asd" * " asd")), "asd", $(Main.workspace#5.Computed("asd" * "asd")), "asd", $(Main.workspace#5.Computed("asd" * "asd")), "asd", $(Main.workspace#5.Computed("asd" * "asd")), "asd", $(Main.workspace#5.Computed("asd" * "asd")), "asd", $(Main.workspace#5.Computed("asd" * "asd")), "asd")

@test always_false("asd"*"asd","asd","asd"*" asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd")

👀 Reading hidden code

16.0 ms

"asdasd"

"asd"

"asd asd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

"asdasd"

"asd"

("asd"*"asd","asd","asd"*" asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd","asd"*"asd","asd")

👀 Reading hidden code

24.4 μs

# @test (@test t isa Pass) isa Pass

👀 Reading hidden code

9.2 μs

true

@test π ≈ 3.14 atol=0.01 rtol=1

👀 Reading hidden code

32.7 ms

begin

macro test(expr...)

test(expr...; __module__=__module__)

end

function Base.show(io::IO, m::MIME"text/html", call::Union{WrongCall,CorrectCall})

infix = if Meta.isexpr(call.expr, :call)

fname = call.expr.args[1]

Meta.isbinaryoperator(fname)

else

false

end

classes = [

"pluto-test",

"call",

(isa(call,CorrectCall) ? "correct" : "wrong"),

(isa(call,Pass) ? "pass" : "fail"),

infix ? "infix-operator" : "prefix-operator",

]

result = @htl("""

const div = currentScript.parentElement

div.addEventListener("click", (e) => {

if(!div.classList.contains("expanded") || e.target.closest("pt-dot:not(.floating)") != null){

div.classList.toggle("expanded")

e.stopPropagation()

}

})

const throttled = (f, delay) => {

const waiting = { current: false }

return () => {

if (!waiting.current) {

f()

waiting.current = true

setTimeout(() => {

f()

waiting.current = false

}, delay)

}

const dot_top = div.querySelector("pt-dot.top")

const dot_bot = div.querySelector("pt-dot.bottom")

const intersect = (r) => {

const topdistance = r.top

const botdistance = window.visualViewport.height - r.bottom

const t = (x) => `translate(\${2*Math.sqrt(Math.max(0,-50-x))}px,0)`

dot_top.style.transform = t(topdistance)

dot_bot.style.transform = t(botdistance)

div.classList.toggle("show-top-float", topdistance < 4)

div.classList.toggle("show-bottom-float", botdistance < 4)

}

window.addEventListener("scroll", throttled(() => {

intersect(dot.getBoundingClientRect())

}, 100))

let observer = new IntersectionObserver((es) => {

const e = es[0]

intersect(e.boundingClientRect)

}, {

rootMargin: '-4px',

threshold: 1.0

});

const dot = div.querySelector("pt-dot")

observer.observe(dot)

invalidation.then(() => {

observer.unobserve(dot)

})

Array.from(div.querySelectorAll("pt-dot.floating")).forEach(e => {

e.addEventListener("click", () => dot.scrollIntoView({behavior: "smooth", block: "center", inline: "nearest"}))

})

</script>

<pt-dot></pt-dot>

<pt-dot class="floating top"></pt-dot>

<pt-dot class="floating bottom"></pt-dot>

$(frames(display_slotted.( call.steps)))

</div>

""")

Base.show(io, m, result)

end

# function Base.show(io::IO, m::MIME"text/html", c::Correct)

# result = @htl("""

# <div class=$([

# "pluto-test", "pass", "correct",

# ])>

# <pt-dot></pt-dot>

# <span>$((string(remove_linenums(c.expr))))</span>

# </div>

# """)

# Base.show(io, m, result)

# end

end

👀 Reading hidden code

2.4 ms

flatmap (generic function with 1 method)

flatmap(args...) = vcat(map(args...)...)

👀 Reading hidden code

476 μs

commas (generic function with 2 methods)

function commas(xs, comma=@htl("<span class='comma'>, </span>"))

flatmap(enumerate(xs)) do (i,x)

if i == length(xs)

[x]

else

[x,comma]

end

👀 Reading hidden code

235 ms

embed_display (generic function with 1 method)

emb = embed_display

👀 Reading hidden code

11.4 μs

div (generic function with 1 method)

div(x; class="", style="") = @htl("<div class=$(class) style=$(style)>$(x)</div>")

👀 Reading hidden code

487 ms

div (generic function with 2 methods)

div(; class="", style="") = x -> @htl("<div class=$(class) style=$(style)>$(x)</div>")

👀 Reading hidden code

2.0 ms

👀 Reading hidden code

68.2 μs

prettycolors (generic function with 1 method)

prettycolors(e) = Markdown.MD([Markdown.Code("julia", string(remove_linenums(e)))])

👀 Reading hidden code

492 μs

remove_linenums (generic function with 1 method)

remove_linenums(e::Expr) = if e.head === :macrocall

Expr(e.head, (remove_linenums(x) for x in e.args)...)

else

Expr(e.head, (remove_linenums(x) for x in e.args if !(x isa LineNumberNode))...)

end

👀 Reading hidden code

1.9 ms

remove_linenums (generic function with 2 methods)

remove_linenums(x) = x

👀 Reading hidden code

341 μs

DEbugging 1

md"""

# DEbugging 1

"""

👀 Reading hidden code

177 μs

onestep (generic function with 1 method)

function onestep(e::Expr; m=Module())

results = Any[]

# push!(results, e)

arg_results = Any[a for a in e.args]

for (i,a) in enumerate(e.args)

arg_results[i] = if a isa QuoteNode

elseif (e.head === :call || e.head === :let) && i == 1

elseif a isa Expr

inner_results = onestep(a; m=m)

for ir in inner_results

arg_results[i] = ir

push!(results, Expr(e.head, arg_results...))

end

inner_results[end]

else

end

# push!(results, Expr(e.head, arg_results...))

end

push!(results, Core.eval(m, Expr(e.head, arg_results...)))

results

end

👀 Reading hidden code

3.6 ms

expr_debug (generic function with 1 method)

function expr_debug(x; )

e = remove_linenums(x)

Any[e, onestep(e)...]

end

👀 Reading hidden code

542 μs

UInt64

👀 Reading hidden code

2.4 ms

expr_hash (generic function with 1 method)

👀 Reading hidden code

1.2 ms

expr_hash (generic function with 2 methods)

👀 Reading hidden code

379 μs

debug_result = expr_debug(:(

let

r = if rand(Bool)

else

end

y = sqrt(4)

y == sqrt(sqrt(r))

end

));

👀 Reading hidden code

45.8 ms

@bind step Slider(1:length(debug_result))

👀 Reading hidden code

732 μs

let
    r = if rand(Bool)
            20
        else
            16
        end
    y = sqrt(4)
    y == sqrt(sqrt(r))
end

debug_result[step] |> prettycolors

👀 Reading hidden code

87.4 ms

Debugging 1.5

md"""

# Debugging 1.5

"""

👀 Reading hidden code

187 μs

struct Computed

end

👀 Reading hidden code

886 μs

computed (generic function with 1 method)

computed(x) = Computed(x)

👀 Reading hidden code

364 μs

expand_computed (generic function with 1 method)

expand_computed(x) = x

👀 Reading hidden code

351 μs

expand_computed (generic function with 2 methods)

expand_computed(c::Computed) = c.x

👀 Reading hidden code

400 μs

expand_computed (generic function with 3 methods)

expand_computed(e::Expr) = Expr(e.head, expand_computed.(e.args)...)

👀 Reading hidden code

477 μs

onestep_light (generic function with 1 method)

onestep_light(x::Any) = [lazycomputedwrap(x)]

👀 Reading hidden code

392 μs

lazyevalwrap (generic function with 1 method)

function lazyevalwrap(x)

Expr(:($), x)

end

👀 Reading hidden code

348 μs

lazycomputedwrap (generic function with 1 method)

function lazycomputedwrap(x)

Computed

Expr(:($), Expr(:call, GlobalRef(@__MODULE__, :Computed), x))

end

👀 Reading hidden code

453 μs

:([1, 2] + $(Expr(:$, :(Main.workspace#5.Computed([1, 2, z])))))

Expr(:call, :+, :([1,2]), lazycomputedwrap(:([1,2,z])))

👀 Reading hidden code

29.9 μs

Any

:(sqrt(first($(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))

:(sqrt($(Expr(:$, :(Main.workspace#5.Computed(first($(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))))))

:($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(first($(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))))))))))

onestep_light(:(sqrt(first([1,2]))))

👀 Reading hidden code

163 ms

@cool (macro with 1 method)

macro cool()

x1 = Expr(:call, :+, :([1,2]), lazycomputedwrap(:([1,2,z])))

# xs = [x1,x1]

xs = onestep_light(:(sqrt(first([1,2]))))[1:1]

quote

# $(esc(Expr(:quote, xs)))

# $(esc([Expr(:quote, x1), Expr(:quote, x1)]))

# $([esc(Expr(:quote, x1)), esc(Expr(:quote, x1))])

# $([esc(Expr(:quote, x1)), esc(Expr(:quote, x1))]...)

# [$([esc(Expr(:quote, x1)), esc(Expr(:quote, x1))]...)]

[$([esc(Expr(:quote, x)) for x in xs]...)]

# [$(esc(Expr(:quote, x1))), $(esc(Expr(:quote, x1)))]

# [$(esc(Expr(:quote, x)))]

end

👀 Reading hidden code

1.3 ms

@showme (macro with 1 method)

macro showme(expr)

quote

$(Expr(:quote, Expr(:quote, expr)))

end

👀 Reading hidden code

495 μs

:($(Expr(:quote, :(a + $(Expr(:$, :b))))))

@showme a + $b

👀 Reading hidden code

4.0 ms

Main.workspace#6

@__MODULE__

👀 Reading hidden code

16.6 μs

Error message

LoadError: UndefVarError: workspace2594 not defined

in expression starting at /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3 no interpolate.jl#==#fce0b2de-7f7b-4ce8-8a16-079428041fb8:2

Stack trace

Here is what happened, the most recent locations are first:

from This cell: line 1

module XX	z = Main.workspace2594.@cool()

module XX

z = Main.workspace2594.@cool()

end

👀 Reading hidden code

---

Error message

UndefVarError: z not defined

XX.z

👀 Reading hidden code

---

Expr

:(sqrt(first(Computed([1, 2]))))

let

z = 1299

@cool()

end

👀 Reading hidden code

41.0 ms

Array{Expr}((1,))
  1: Expr
    head: Symbol call
    args: Array{Any}((2,))
      1: Symbol sqrt
      2: Expr
        head: Symbol call
        args: Array{Any}((2,))
          1: Symbol first
          2: Computed
            x: Array{Int64}((2,)) [1, 2]

@cool() |> Dump

👀 Reading hidden code

4.1 ms

Expr
  head: Symbol block
  args: Array{Any}((2,))
    1: LineNumberNode
      line: Int64 14
      file: Symbol /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3 no interpolate.jl#==#61688af2-169e-4c1f-a37f-cc7cc35679dc
    2: Expr
      head: Symbol vect
      args: Array{Any}((1,))
        1: Expr
          head: Symbol call
          args: Array{Any}((4,))
            1: GlobalRef
              mod: Module Core
              name: Symbol _expr
            2: QuoteNode
              value: Symbol call
            3: QuoteNode
              value: Symbol sqrt
            4: Expr
              head: Symbol call
              args: Array{Any}((4,))
                1: GlobalRef
                  mod: Module Core
                  name: Symbol _expr
                2: QuoteNode
                  value: Symbol call
                3: QuoteNode
                  value: Symbol first
                4: Expr
                  head: Symbol call
                  args: Array{Any}((2,))
                    1: GlobalRef
                      mod: Module Main.workspace#5
                      name: Symbol Computed
                    2: Expr
                      head: Symbol vect
                      args: Array{Any}((2,))
                        1: Int64 1
                        2: Int64 2

Dump(@macroexpand @cool(); maxdepth=999)

👀 Reading hidden code

5.2 ms

onestep_light (generic function with 2 methods)

function onestep_light(e::Expr)

results = Any[]

seval(ex) = lazycomputedwrap(ex)#Computed(Core.eval(m,ex))

# will be modified

arg_results = Any[a for a in e.args]

push_intermediate() = push!(results, Expr(e.head, arg_results...))

if e.head === :call || e.head === :begin || e.head === :block

for (i,a) in enumerate(e.args)

if a isa QuoteNode

elseif (Meta.isexpr(e, :call) || Meta.isexpr(e, :let)) && i == 1

elseif a isa Symbol

arg_results[i] = seval(a)

push_intermediate()

elseif a isa Expr

inner_results = onestep_light(a)

for ir in inner_results

arg_results[i] = ir

push_intermediate()

end

arg_results[i] = inner_results[end]

else

end

push!(results, seval(expand_computed(Expr(e.head, arg_results...))))

results

end

👀 Reading hidden code

5.3 ms

Vector{Expr}

Expr

:(2 + $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :i)))))))

:($(Expr(:$, :(Main.workspace#5.Computed(2 + $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :i)))))))))))

map(1:1) do i

@eval_step_by_step 2 + $i

end

👀 Reading hidden code

110 μs

step_by_step (generic function with 1 method)

function step_by_step(expr; __module__)

Computed

onestep_light

escquote(x) = x#Core.eval(__module__, Expr(:quote, x))

if can_interpret(expr)

quote

# Any[$(QuoteNode(expr)), $(escquote.(onestep_light(expr)))...]

# $(escquote.(onestep_light(expr)))

end

escquote.(onestep_light(expr))

else

quote

[$(QuoteNode(expr)), Computed($(esc(expr)))]

end

👀 Reading hidden code

2.6 ms

Expr

:(sqrt(length($(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))

:(sqrt($(Expr(:$, :(Main.workspace#5.Computed(length($(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))))))

:($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(length($(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))))))))))

@eval_step_by_step sqrt(length([1,2]))

👀 Reading hidden code

89.7 μs

Any

:(1 + sqrt($(Expr(:$, :(Main.workspace#5.Computed(z))))))

:(1 + $(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(z))))))))))

:($(Expr(:$, :(Main.workspace#5.Computed(1 + $(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(z))))))))))))))

onestep_light(:(1+sqrt(z)))

👀 Reading hidden code

32.3 ms

:(1 + sqrt($(Expr(:$, :z))))

ezz = let

e = Expr(:$, :z)

:(1 + sqrt($e))

end

👀 Reading hidden code

48.2 μs

@eyo (macro with 1 method)

macro eyo()

ezz

end

👀 Reading hidden code

361 μs

Error message

syntax: "$" expression outside quote around /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3 no interpolate.jl#==#611800fe-2ba5-4d89-a3aa-8933ec60bf2e:1

@eyo()

👀 Reading hidden code

---

Error message

syntax: "$" expression outside quote

computer bad, you GREAT!

eval(:(sqrt(length($(Expr(:$, :(Main.workspace2618.Computed([1, 2]))))))))

👀 Reading hidden code

---

@eval_step_by_step (macro with 1 method)

macro eval_step_by_step(e)

step_by_step

quote

[$(step_by_step(e; __module__=__module__))...]

end

👀 Reading hidden code

665 μs

@wow (macro with 1 method)

macro wow(ex)

# esc(Core.eval(__module__, Expr(:quote, e)))

esc(Expr(:call, GlobalRef(Core, :eval), __module__, Expr(:quote, ex)))

end

👀 Reading hidden code

508 μs

quote
    [Expr[:(sqrt(sqrt($(Expr(:$, :(Main.workspace#5.Computed(3 + 2))))))), :(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(3 + 2))))))))))), :($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(3 + 2)))))))))))))))]...]
end

let

i = 123

remove_linenums( @macroexpand @eval_step_by_step sqrt(sqrt(3 + 2)) )

end

👀 Reading hidden code

1.5 ms

Expr

quote
    #= /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3 no interpolate.jl#==#a661e172-6afb-42ff-bd43-bb5b787ee5ed:4 =#
    [Expr[:(2342342 + $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :i))))))), :($(Expr(:$, :(Main.workspace#5.Computed(2342342 + $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :i)))))))))))]...]
end

map(1:1) do i

@macroexpand @eval_step_by_step 2342342 + $i

end

👀 Reading hidden code

22.0 ms

quote
    #= /home/runner/work/disorganised-mess/disorganised-mess/testing and debugging 3 no interpolate.jl#==#a661e172-6afb-42ff-bd43-bb5b787ee5ed:4 =#
    [Expr[:($(Expr(:$, :(Main.workspace#5.Computed(x)))) == [1, 2]), :($(Expr(:$, :(Main.workspace#5.Computed(x)))) == $(Expr(:$, :(Main.workspace#5.Computed([1, 2]))))), :($(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(x)))) == $(Expr(:$, :(Main.workspace#5.Computed([1, 2])))))))))]...]
end

@macroexpand @eval_step_by_step x == [1,2]

👀 Reading hidden code

158 μs

Expr

:($(Expr(:$, :(Main.workspace#5.Computed($(Expr(:(=), :xasdf, 123)))))))

@eval_step_by_step xasdf = 123

👀 Reading hidden code

58.7 μs

Error message

UndefVarError: xasdf not defined

Stack trace

Here is what happened, the most recent locations are first:

from This cell: line 1
```
xasdf
```

C'est la vie !

xasdf

👀 Reading hidden code

---

Any

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    sqrt(sqrt(sqrt(5)))
end

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    sqrt(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))
end

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))))))
end

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    $(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))))))))))
end

:($(Expr(:$, :(Main.workspace#5.Computed(begin
          $(Expr(:$, :(Main.workspace#5.Computed(1 + 2))))
          $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
          $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
          $(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))))))))))
      end)))))

onestep_light(quote

1+2

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums)

👀 Reading hidden code

5.1 ms

can_interpret (generic function with 1 method)

can_interpret(x) = true

👀 Reading hidden code

459 μs

can_interpret_call_arg (generic function with 1 method)

can_interpret_call_arg(e::Expr) = !(e.head === :(...) || e.head === :kw || e.head === :parameters)

👀 Reading hidden code

646 μs

can_interpret_call_arg (generic function with 2 methods)

can_interpret_call_arg(x) = true

👀 Reading hidden code

364 μs

true

Meta.isbinaryoperator(:(==))

👀 Reading hidden code

17.5 ms

can_interpret (generic function with 2 methods)

can_interpret(e::Expr) = if false

false

elseif e.head === :call && !all(can_interpret_call_arg, e.args)

false

# elseif e.head === :(=) || e.head === :macrocall

# false

else

all(can_interpret, e.args)

end

👀 Reading hidden code

657 μs

Displaying

👀 Reading hidden code

175 μs

👀 Reading hidden code

66.6 μs

find_computed! (generic function with 1 method)

find_computed!(found, c::Computed) = push!(found, c)

👀 Reading hidden code

405 μs

find_computed! (generic function with 2 methods)

find_computed!(found, expr::Expr) = find_computed!.([found], expr.args)

👀 Reading hidden code

501 μs

find_computed! (generic function with 3 methods)

find_computed!(found, x) = nothing

👀 Reading hidden code

354 μs

find_computed (generic function with 1 method)

find_computed(x) = let

r = Any[]

find_computed!(r, x)

end

👀 Reading hidden code

505 μs

Vector{Any}

Any

onestep_light(quote

1+2

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums) .|> find_computed

👀 Reading hidden code

1.1 s

slot! (generic function with 1 method)

slot!(found, c::Computed) = let

k = Symbol("__slot", join(rand('a':'z', 16)), "__")

found[k] = c

end

👀 Reading hidden code

626 μs

slot! (generic function with 2 methods)

slot!(found, x) = x

👀 Reading hidden code

386 μs

slot! (generic function with 3 methods)

slot!(found, e::Expr) = Expr(e.head, slot!.([found], e.args)...)

👀 Reading hidden code

518 μs

slot (generic function with 1 method)

slot(e) = let

d = Dict{Symbol,Any}()

new_e = slot!(d, e)

d, new_e

end

👀 Reading hidden code

560 μs

Tuple{Dict{Symbol, Any}, Expr}

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + (7 - 6)
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
    2 + 3
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    4 + 5
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    sqrt(sqrt(sqrt(5)))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    sqrt(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))))))
end

Dict{Symbol, Any}Dict

quote
    $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
    $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
    $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
    $(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))))))))))
end

Dict{Symbol, Any}Dict

:($(Expr(:$, :(Main.workspace#5.Computed(begin
          $(Expr(:$, :(Main.workspace#5.Computed($(Expr(:$, :(Main.workspace#5.Computed(1 + 2)))) + $(Expr(:$, :(Main.workspace#5.Computed(7 - 6))))))))
          $(Expr(:$, :(Main.workspace#5.Computed(2 + 3))))
          $(Expr(:$, :(Main.workspace#5.Computed(4 + 5))))
          $(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt($(Expr(:$, :(Main.workspace#5.Computed(sqrt(5)))))))))))))))
      end)))))

onestep_light(quote

(1+2) + (7-6)

2+3

4+5

sqrt(sqrt(sqrt(5)))

end |> remove_linenums) .|> slot

👀 Reading hidden code

371 ms

preish (generic function with 1 method)

preish(x) = @htl("<pre-ish>$(x)</pre-ish>")

👀 Reading hidden code

536 μs

display_slotted (generic function with 1 method)

function display_slotted(expr)

d, e = slot(expr)

s = string(e |> remove_linenums)

lines = split(s, "\n")

r = r"\_\_slot[a-z]{16}\_\_"

@htl("""<slotted-code>

map(lines) do l

keys = [Symbol(m.match) for m in eachmatch(r, l)]

rest = split(l, r; keepempty=true)

result = vcat((

[(isempty(r) ? @htl("") : preish(r)), embed_display(d[k].x)]

for (r,k) in zip(rest, keys)

)...)

push!(result, preish(last(rest)))

@htl("<line-like>$(result)</line-like>")

end

)

</slotted-code>""")

end

👀 Reading hidden code

12.9 ms

html"""

<style>

slotted-code {

font-family: "JuliaMono", monospace;

font-size: .75rem;

display: flex;

flex-direction: column;

}

pre-ish {

white-space: pre;

}

line-like {

display: flex;

align-items: baseline;

}

"""

👀 Reading hidden code

104 μs

# rs = @eval_step_by_step(begin

# (1+2) + (7-6)

# first(2000 .+ 30 .* rand(2+2))

# 4+5

# sqrt(sqrt(sqrt(5)))

# end) .|> display_slotted

👀 Reading hidden code

9.6 μs

using Plots

👀 Reading hidden code

3.6 s

plot (generic function with 1 method)

plot(args...; kwargs...) = Plots.plot(args...; size=(100,100), kwargs...)

👀 Reading hidden code

1.4 ms

HypertextLiteral.Result

begin

$(Main.workspace#5.Computed(1 + 2)) + (7 - 6)

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

plot(2000 .+ 30 .* rand($(Main.workspace#5.Computed(2 + 2))))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

plot(2000 .+ 30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

plot(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

4 + 5

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

sqrt(sqrt(sqrt(5)))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

sqrt(sqrt($(Main.workspace#5.Computed(sqrt(5)))))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

sqrt($(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt(5)))))))

end

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt(5)))))))))

end

$(Main.workspace#5.Computed(begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt(5)))))))))

end))

rs = @eval_step_by_step(begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

end) .|> display_slotted

👀 Reading hidden code

424 ms

@bind rindex Slider(eachindex(rs))

👀 Reading hidden code

30.8 ms

begin

$(Main.workspace#5.Computed(1 + 2)) + (7 - 6)

plot(2000 .+ 30 .* rand(2 + 2))

4 + 5

sqrt(sqrt(sqrt(5)))

end

rs[rindex]

👀 Reading hidden code

11.8 μs

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt(5)))))))))

end

frames(rs)

👀 Reading hidden code

34.9 μs

@visual_debug (macro with 1 method)

macro visual_debug(expr)

frames

display_slotted

var"@eval_step_by_step"

quote

@eval_step_by_step($(expr)) .|> display_slotted |> frames

end

👀 Reading hidden code

657 μs

begin

$(Main.workspace#5.Computed($(Main.workspace#5.Computed(1 + 2)) + $(Main.workspace#5.Computed(7 - 6))))

$(Main.workspace#5.Computed(plot($(Main.workspace#5.Computed(2000 .+ $(Main.workspace#5.Computed(30 .* $(Main.workspace#5.Computed(rand($(Main.workspace#5.Computed(2 + 2))))))))))))

$(Main.workspace#5.Computed(4 + 5))

$(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt($(Main.workspace#5.Computed(sqrt(5)))))))))

end

@visual_debug begin

(1+2) + (7-6)

plot(2000 .+ 30 .* rand(2+2))

4+5

sqrt(sqrt(sqrt(5)))

end

👀 Reading hidden code

4.6 ms

frames (generic function with 1 method)

function frames(fs)

l = length(fs)

startframe = l > 2 ? l - 1 : l

@htl("""

<p-frame-viewer>

<p-frames>

$(fs)

</p-frames>

<p-frame-controls>

</p-frame-controls>

const div = currentScript.parentElement

const input = div.querySelector("p-frame-controls > input.timescrub")

const frames = div.querySelector("p-frames")

const setviz = () => {

Array.from(frames.children).forEach((f,i) => {

f.style.display = i + 1 === input.valueAsNumber ? "inherit" : "none"

})

}

setviz()

input.addEventListener("input", setviz)

</script>

</p-frame-viewer>

""")

end

👀 Reading hidden code

857 μs

👀 Reading hidden code

75.3 μs

👀 Reading hidden code

68.4 μs

👀 Reading hidden code

66.6 μs

👀 Reading hidden code

66.9 μs

👀 Reading hidden code

65.8 μs

👀 Reading hidden code

65.5 μs

In the cloud (experimental)

On your computer

Frontmatter

Preview

PlutoTest.jl

Time travel

(You need `Pluto#main` to run this notebook)

Type definitions

Test macro

DEbugging 1

Debugging 1.5

Displaying

PlutoTest.jl

Time travel

(You need Pluto#main to run this notebook)

Type definitions

Test macro

DEbugging 1

Debugging 1.5

Displaying

(You need `Pluto#main` to run this notebook)